
const fs = require('fs');

// 添加键值对到JSON文件的指定路径
function addKeyValueToJsonPath (jsonFilePath, keyPath, newKey, newValue) {
  // 直接使用 addMultipleKeyValuesToJsonPath 函数，将单个键值对转换为数组格式
  return addMultipleKeyValuesToJsonPath(jsonFilePath, keyPath, [{ key: newKey, value: newValue }]);
}

// 一次性向JSON文件的指定路径添加多个键值对
function addMultipleKeyValuesToJsonPath (jsonFilePath, keyPath, keyValuePairs) {
  try {
    // 解析keyPath，将路径分割成数组
    const pathParts = keyPath.split('.');

    // 读取JSON文件内容
    const jsonContent = fs.readFileSync(jsonFilePath, 'utf8');

    // 检查文件是否为空或不是有效的JSON格式
    if (!jsonContent.trim() || !jsonContent.trim().startsWith('{')) {
      throw new Error('文件为空或不是有效的JSON格式');
    }
    let currentDepth = 0;
    let insideString = false;
    let escapeNext = false;
    let braceStack = [];

    // 遍历JSON文本查找目标路径
    for (let i = 0; i < jsonContent.length; i++) {
      const char = jsonContent[i];

      // 处理转义字符
      if (escapeNext) {
        escapeNext = false;
        continue;
      }

      if (char === '\\') {
        escapeNext = true;
        continue;
      }

      // 处理字符串
      if (char === '"' && !insideString) {
        insideString = true;
        continue;
      }

      if (char === '"' && insideString) {
        insideString = false;

        // 检查是否找到当前路径部分
        const keyStart = i - pathParts[currentDepth].length - 1;
        if (keyStart >= 0 && jsonContent.substring(keyStart + 1, i) === pathParts[currentDepth]) {
          // 找到当前路径部分
          currentDepth++;

          // 如果找到完整路径
          if (currentDepth === pathParts.length) {
            // 查找对应的值（对象）的开始位置
            let valueStart = -1;
            for (let j = i + 1; j < jsonContent.length; j++) {
              if (jsonContent[j] === '{') {
                valueStart = j;
                break;
              } else if (jsonContent[j] !== ' ' && jsonContent[j] !== ':') {
                // 如果找到的不是对象开始，说明路径不正确
                throw new Error(`路径 ${keyPath} 不指向一个对象`);
              }
            }

            if (valueStart === -1) {
              throw new Error(`无法找到路径 ${keyPath} 对应的对象`);
            }

            // 找到对象的结束位置
            let braceCount = 1;
            let valueEnd = -1;

            for (let j = valueStart + 1; j < jsonContent.length; j++) {
              if (jsonContent[j] === '{') {
                braceCount++;
              } else if (jsonContent[j] === '}') {
                braceCount--;
                if (braceCount === 0) {
                  valueEnd = j;
                  break;
                }
              }
            }

            if (valueEnd === -1) {
              throw new Error(`无法找到路径 ${keyPath} 对应对象的结束位置`);
            }

            // 构建新的JSON内容
            let newJsonContent = jsonContent;
            for (const index in keyValuePairs) {
              if (Object.prototype.hasOwnProperty.call(keyValuePairs, index)) {
                const newValueObj = keyValuePairs[index];
                const newKey = newValueObj.key;
                const newValue = newValueObj.value;

                // 检查对象内是否已有内容
                const objectContent = newJsonContent.substring(valueStart + 1, valueEnd).trim();
                let newKeyValuePair = `\n${new Array(currentDepth + 1).fill('  ').join('')}"${newKey}": ${JSON.stringify(newValue)}`;

                if (Number(index) === keyValuePairs.length - 1) {
                  newKeyValuePair += `\n${new Array(currentDepth).fill('  ').join('')}`;
                }

                if (objectContent === '') {
                  // 空对象，直接添加新键值对
                  newJsonContent = newJsonContent.substring(0, valueStart + 1) +
                    ` ${newKeyValuePair} ` +
                    newJsonContent.substring(valueEnd);
                  valueEnd = valueEnd + newKeyValuePair.length + 2;
                } else {
                  const newContent = newJsonContent.substring(0, valueEnd)
                  let endSpace = newContent.match(/\s+$/);
                  endSpace = endSpace ? endSpace[0] : ''

                  // 非空对象，添加逗号和新键值对
                  newJsonContent = newContent.replace(/\s+$/, '') +
                    `, ${newKeyValuePair}` +
                    newJsonContent.substring(valueEnd);
                  valueEnd = valueEnd + newKeyValuePair.length + 2 - endSpace.length;
                }
              }
            }

            // 写入文件
            fs.writeFileSync(jsonFilePath, newJsonContent, 'utf8');
            console.log(`成功添加键值对: ${JSON.stringify(keyValuePairs)} 到路径 ${keyPath}`);
            return true;
          }
        }
        continue;
      }

      // 跳过字符串内容
      if (insideString) {
        continue;
      }

      // 处理对象层级
      if (char === '{') {
        braceStack.push(i);
      } else if (char === '}') {
        braceStack.pop();
        // 如果当前深度大于0但是对象已经结束，说明路径不存在
        if (currentDepth > 0 && braceStack.length < currentDepth) {
          currentDepth = braceStack.length;
        }
      }
    }

    // 如果遍历完整个文件都没找到目标路径，则创建该路径
    console.log(`路径 ${keyPath} 不存在，将创建该路径`);

    // 使用文本流处理方式创建路径并添加键值对
    return createPathWithTextProcessing(jsonContent, jsonFilePath, keyPath, keyValuePairs);
  } catch (error) {
    console.error(`添加键值对到JSON路径时出错:`, error);
    return false;
  }
}

// 使用文本流处理方式创建路径并添加键值对
function createPathWithTextProcessing (jsonContent, jsonFilePath, keyPath, keyValuePairs) {
  try {
    // 解析keyPath，将路径分割成数组
    const pathParts = keyPath.split('.');

    // 检查第一级路径是否
    const rootKey = pathParts[0];
    const rootKeyRegex = new RegExp(`[{,\\s\\n\\r]+"${rootKey}"\\s*:\\s*\\{`, 'g');

    let rootKeyMatch = rootKeyRegex.exec(jsonContent);

    // 构建新的JSON内容
    let newJsonContent = jsonContent;

    if (!rootKeyMatch) {
      // 从根对象开始
      let rootPos = -1;

      // 找到根对象的开始位置
      for (let i = 0; i < jsonContent.length; i++) {
        if (jsonContent[i] === '{') {
          rootPos = i;
          break;
        }
      }

      if (rootPos === -1) {
        throw new Error('无法找到JSON根对象');
      }

      // 构建新的路径结构
      let newPathStructure = `\n  "${pathParts[0]}": {}\n`;

      // 检查JSON内容是否为空对象
      const isEmptyRoot = jsonContent.substring(rootPos + 1).trim().startsWith('}');

      if (isEmptyRoot) {
        // 空对象，直接添加新路径
        newJsonContent = jsonContent.substring(0, rootPos + 1) +
          ` ${newPathStructure} ` +
          jsonContent.substring(rootPos + 1);
      } else {
        // 非空对象，添加逗号和新路径
        newJsonContent = jsonContent.substring(0, rootPos + 1) +
          jsonContent.substring(rootPos + 1).replace(/}\s*$/, `, ${newPathStructure} }`);
      }
    }
    return modifyExistingStructure(newJsonContent, jsonFilePath, pathParts, keyValuePairs);
  } catch (error) {
    console.error(`创建路径并添加键值对时出错:`, error);

    return false
  }
}

// 修改现有结构
function modifyExistingStructure (jsonContent, jsonFilePath, pathParts, keyValuePairs) {
  try {
    // 使用纯文本处理方式，避免JSON.parse
    // 查找第一个顶级键的位置
    const rootKey = pathParts[0];

    const rootKeyRegex = new RegExp(`"${rootKey}"\\s*:\\s*\\{`, 'g');

    let match;
    let rootKeyPos = -1;

    const leftKuo = new RegExp(`\\{`, 'g');

    const leftKuoMath = []
    while ((match = leftKuo.exec(jsonContent)) !== null) {
      leftKuoMath.push({
        text: match[0],
        index: match.index,
        input: match.input
      });
    }
    if (!leftKuoMath) {
      throw new Error('json格式错误，无法找到左括号');
    }
    const rightKuo = new RegExp(`\\}`, 'g');

    const rightKuoMath = []
    while ((match = rightKuo.exec(jsonContent)) !== null) {
      rightKuoMath.push({
        text: match[0],
        index: match.index,
        input: match.input
      });
    }
    if (!rightKuoMath) {
      throw new Error('json格式错误，无法找到右括号');
    }
    if (leftKuoMath.length !== rightKuoMath.length) {
      throw new Error('json格式错误，左括号和右括号数量不一致');
    }

    while ((match = rootKeyRegex.exec(jsonContent)) !== null) {
      const leftKuoIndex = leftKuoMath.findIndex(left => left.index > match.index);
      const rightKuoIndex = rightKuoMath.findIndex(right => right.index > match.index);

      if (leftKuoIndex - rightKuoIndex === 1) {

        // 只处理第一个匹配项
        rootKeyPos = match.index;
        break;
      }
    }

    if (rootKeyPos === -1) {
      console.error(`无法找到顶级键 ${rootKey}`);
      return false;
    }

    // 提取该顶级键对应的对象
    const startPos = rootKeyPos + match[0].length - 1; // 对象开始位置
    let braceCount = 1;
    let endPos = startPos + 1;

    // 查找对象结束位置
    for (let i = startPos + 1; i < jsonContent.length; i++) {
      if (jsonContent[i] === '{') {
        braceCount++;
      } else if (jsonContent[i] === '}') {
        braceCount--;
      }

      if (braceCount === 0) {
        endPos = i;
        break;
      }
    }

    // 提取对象内容
    const objectContent = jsonContent.substring(startPos, endPos + 1);

    // 递归查找路径
    let currentPath = rootKey;
    let currentContent = objectContent;
    let pathFound = true;

    // 从第二级路径开始查找
    for (let i = 1; i < pathParts.length; i++) {
      currentPath += '.' + pathParts[i];

      const partRegex = new RegExp(`"${pathParts[i]}"\\s*:\\s*(\\{|\\[)`, 'g');
      let partMatch;
      let found = false;

      while ((partMatch = partRegex.exec(currentContent)) !== null) {
        found = true;

        // 找到匹配位置后，提取该对象的内容
        const partStartPos = partMatch.index + partMatch[0].length - 1; // 对象开始位置
        let partBraceCount = 1;
        let partEndPos = partStartPos + 1;

        // 查找对象结束位置
        for (let j = partStartPos + 1; j < currentContent.length; j++) {
          if (currentContent[j] === '{' || currentContent[j] === '[') {
            partBraceCount++;
          } else if (currentContent[j] === '}' || currentContent[j] === ']') {
            partBraceCount--;
          }

          if (partBraceCount === 0) {
            partEndPos = j;
            break;
          }
        }

        // 更新当前内容为找到的对象
        currentContent = currentContent.substring(partStartPos, partEndPos + 1);
        break;
      }

      if (!found) {
        pathFound = false;
        break;
      }
    }

    // 构建键值对字符串
    let keyValueStr = '';
    for (let i = 0; i < keyValuePairs.length; i++) {
      const pair = keyValuePairs[i];
      keyValueStr += `\n${new Array(pathParts.length + 1).fill('  ').join('')}"${pair.key}": ${JSON.stringify(pair.value)}`;
      if (i < keyValuePairs.length - 1) {
        keyValueStr += ',';
      }
    }

    let newJsonContent;

    if (pathFound) {
      newJsonContent = replaceJsonContent(jsonContent, pathParts, currentContent, keyValueStr);
      console.log(`成功添加键值对到现有路径 ${pathParts.join('.')}`);
    } else {
      // 路径不存在，需要创建
      // 找到最后一个存在的路径
      let lastFoundPath = rootKey;
      let lastFoundContent = objectContent;
      let lastFoundPos = -1;

      // 从第二级路径开始查找最后一个存在的路径
      for (let i = 1; i < pathParts.length; i++) {
        const partRegex = new RegExp(`"${pathParts[i]}"\\s*:\\s*(\\{|\\[)`, 'g');
        let partMatch;
        let found = false;

        while ((partMatch = partRegex.exec(lastFoundContent)) !== null) {
          found = true;
          lastFoundPos = partMatch.index;

          // 找到匹配位置后，提取该对象的内容
          const partStartPos = partMatch.index + partMatch[0].length - 1; // 对象开始位置
          let partBraceCount = 1;
          let partEndPos = partStartPos + 1;

          // 查找对象结束位置
          for (let j = partStartPos + 1; j < lastFoundContent.length; j++) {
            if (lastFoundContent[j] === '{' || lastFoundContent[j] === '[') {
              partBraceCount++;
            } else if (lastFoundContent[j] === '}' || lastFoundContent[j] === ']') {
              partBraceCount--;
            }

            if (partBraceCount === 0) {
              partEndPos = j;
              break;
            }
          }

          // 更新当前内容为找到的对象
          lastFoundContent = lastFoundContent.substring(partStartPos, partEndPos + 1);
          lastFoundPath += '.' + pathParts[i];
          break;
        }

        if (!found) {
          break;
        }
      }

      // 构建剩余路径
      const lastFoundPathParts = lastFoundPath.split('.');
      const remainingParts = pathParts.slice(lastFoundPathParts.length);

      if (remainingParts.length > 0) {
        let remainingPathStructure = '';

        // 构建嵌套结构
        for (let i = 0; i < remainingParts.length; i++) {
          remainingPathStructure += `\n${new Array(i + lastFoundPathParts.length + 1).fill('  ').join('')}"${remainingParts[i]}": `;

          if (i < remainingParts.length - 1) {
            remainingPathStructure += '{';
          }
        }

        // 添加键值对
        remainingPathStructure += '{';
        remainingPathStructure += keyValueStr;

        // 闭合所有对象
        for (let i = 0; i < remainingParts.length; i++) {
          remainingPathStructure += `\n${new Array(remainingParts.length + lastFoundPathParts.length - i).fill('  ').join('')}\}`;
        }
        remainingPathStructure += `\n${new Array(lastFoundPathParts.length).fill('  ').join('')}`

        newJsonContent = replaceJsonContent(jsonContent, lastFoundPathParts, lastFoundContent, remainingPathStructure);
      } else {
        newJsonContent = replaceJsonContent(jsonContent, lastFoundPathParts, lastFoundContent, keyValueStr);
      }

      console.log(`成功创建路径 ${pathParts.join('.')} 并添加键值对`);
    }

    // 写入文件
    fs.writeFileSync(jsonFilePath, newJsonContent, 'utf8');
    return true;
  } catch (error) {
    console.error(`修改现有结构时出错:`, error);
    return false;
  }
}

function replaceJsonContent (jsonContent, lastFoundPathParts, lastFoundContent, remainingPathStructure) {
  // 检查当前对象是否为空
  const isEmptyObject = lastFoundContent.trim() === '{}';

  let prePath = ''
  for (let i = 0; i < lastFoundPathParts.length - 1; i++) {
    const Path = lastFoundPathParts[i];
    prePath += `"${Path}"\\s*:.*?`
  }
  prePath += `"${lastFoundPathParts[lastFoundPathParts.length - 1]}"\\s*:\\s*\\{`

  let startMatch = (new RegExp(prePath, 'gs')).exec(jsonContent);
  if (!startMatch) {
    return jsonContent;
  }
  const partStartPos = startMatch.index + startMatch[0].length - 1

  let partBraceCount = 1;
  let partEndPos = partStartPos + 1;

  // 查找对象结束位置
  for (let j = partStartPos + 1; j < jsonContent.length; j++) {
    if (jsonContent[j] === '{' || jsonContent[j] === '[') {
      partBraceCount++;
    } else if (jsonContent[j] === '}' || jsonContent[j] === ']') {
      partBraceCount--;
    }

    if (partBraceCount === 0) {
      partEndPos = j;
      break;
    }
  }


  // 更新对象内容
  let updatedContent;
  if (isEmptyObject) {
    // 空对象，直接添加新路径
    updatedContent = remainingPathStructure
  } else {
    // 非空对象，添加逗号和新路径
    updatedContent = lastFoundContent.substring(1, lastFoundContent.length - 1).replace(/\s+$/, '') +

      (lastFoundContent.substring(1, lastFoundContent.length - 1).trim() ? ', ' : ' ') +
      remainingPathStructure;

  }

  return jsonContent.substring(0, partStartPos + 1) + `${updatedContent}` + jsonContent.substring(partEndPos);
}


// 解析 JSON 字符串，处理重复键
function parseJSONWithDuplicates (jsonStr) {
  // 使用自定义解析器处理JSON字符串，捕获所有键值对包括重复键
  function parseWithDuplicates (jsonStr) {
    // 预处理：移除注释和不必要的空白
    jsonStr = jsonStr.replace(/\/\/.*?\n|\s+/g, ' ').trim();

    // 确保是一个对象
    if (!jsonStr.startsWith('{') || !jsonStr.endsWith('}')) {
      throw new Error('Invalid JSON: must be an object');
    }

    // 提取所有键值对
    const keyValuePairs = [];
    let pos = 1; // 跳过开始的 {

    while (pos < jsonStr.length - 1) { // -1 跳过结束的 }
      // 跳过空白
      while (pos < jsonStr.length && /\s/.test(jsonStr[pos])) pos++;

      // 确保我们有一个键（必须以引号开始）
      if (jsonStr[pos] !== '"') {
        throw new Error(`Expected key at position ${pos}`);
      }

      // 提取键
      pos++; // 跳过开始的引号
      let key = '';
      while (pos < jsonStr.length && jsonStr[pos] !== '"') {
        // 处理转义字符
        if (jsonStr[pos] === '\\' && pos + 1 < jsonStr.length) {
          key += jsonStr[pos] + jsonStr[pos + 1];
          pos += 2;
          continue;
        }
        key += jsonStr[pos];
        pos++;
      }
      pos++; // 跳过结束的引号

      // 跳过空白和冒号
      while (pos < jsonStr.length && jsonStr[pos] !== ':') pos++;
      pos++; // 跳过冒号

      // 跳过空白
      while (pos < jsonStr.length && /\s/.test(jsonStr[pos])) pos++;

      // 提取值
      let value;
      let valueStr = '';

      // 根据值的类型进行不同的处理
      if (jsonStr[pos] === '{') {
        // 对象值
        let braceCount = 1;
        valueStr = '{';
        pos++;

        while (pos < jsonStr.length && braceCount > 0) {
          if (jsonStr[pos] === '{') braceCount++;
          if (jsonStr[pos] === '}') braceCount--;
          valueStr += jsonStr[pos];
          pos++;
        }

        // 递归解析嵌套对象
        try {
          value = parseWithDuplicates(valueStr);
        } catch (e) {
          // 如果递归解析失败，尝试使用标准JSON.parse
          try {
            value = JSON.parse(valueStr);
          } catch (e2) {
            value = valueStr; // 保留原始字符串
          }
        }
      } else if (jsonStr[pos] === '[') {
        // 数组值
        let bracketCount = 1;
        valueStr = '[';
        pos++;

        while (pos < jsonStr.length && bracketCount > 0) {
          if (jsonStr[pos] === '[') bracketCount++;
          if (jsonStr[pos] === ']') bracketCount--;
          valueStr += jsonStr[pos];
          pos++;
        }

        // 解析数组
        try {
          value = JSON.parse(valueStr);
        } catch (e) {
          value = valueStr; // 保留原始字符串
        }
      } else if (jsonStr[pos] === '"') {
        // 字符串值
        valueStr = '"';
        pos++; // 跳过开始的引号

        while (pos < jsonStr.length) {
          // 处理转义字符
          if (jsonStr[pos] === '\\' && pos + 1 < jsonStr.length) {
            valueStr += jsonStr[pos] + jsonStr[pos + 1];
            pos += 2;
            continue;
          }

          if (jsonStr[pos] === '"') {
            valueStr += '"';
            pos++; // 跳过结束的引号
            break;
          }

          valueStr += jsonStr[pos];
          pos++;
        }

        // 解析字符串
        try {
          value = JSON.parse(valueStr);
        } catch (e) {
          value = valueStr.substring(1, valueStr.length - 1); // 移除引号
        }
      } else {
        // 其他值（数字、布尔值、null）
        while (pos < jsonStr.length && jsonStr[pos] !== ',' && jsonStr[pos] !== '}') {
          valueStr += jsonStr[pos];
          pos++;
        }

        valueStr = valueStr.trim();

        // 解析值
        if (valueStr === 'true') value = true;
        else if (valueStr === 'false') value = false;
        else if (valueStr === 'null') value = null;
        else {
          // 尝试解析为数字
          const num = Number(valueStr);
          value = isNaN(num) ? valueStr : num;
        }
      }

      // 添加键值对
      keyValuePairs.push([key, value]);

      // 跳过空白和逗号
      while (pos < jsonStr.length && (jsonStr[pos] === ' ' || jsonStr[pos] === ',' || jsonStr[pos] === '\n')) pos++;
    }

    // 构建结果对象，处理重复键
    const result = {};

    for (const [key, value] of keyValuePairs) {
      if (result[key] === undefined) {
        result[key] = value;
      } else {
        // 如果键已存在，转换为数组
        if (Array.isArray(result[key])) {
          result[key].push(value);
        } else {
          result[key] = [result[key], value];
        }
      }
    }

    return result;
  }

  try {
    // 尝试使用自定义解析器
    return parseWithDuplicates(jsonStr);
  } catch (error) {
    console.error('自定义解析失败，回退到标准解析:', error);

    try {
      // 如果自定义解析失败，尝试使用标准JSON.parse
      return JSON.parse(jsonStr);
    } catch (e) {
      console.error('标准解析也失败:', e);

      // 最后的尝试：使用简单的正则表达式匹配
      const result = {};
      const regex = /"([^"]+)"\s*:\s*("[^"]*"|\{[^\}]*\}|\[[^\]]*\]|[^,\}\]]+)/g;
      let match;

      while ((match = regex.exec(jsonStr)) !== null) {
        const key = match[1];
        let value = match[2];

        // 尝试解析值
        try {
          if (value.startsWith('"') || value.startsWith('{') || value.startsWith('[')) {
            value = JSON.parse(value);
          } else {
            value = JSON.parse(value);
          }
        } catch (err) {
          // 如果解析失败，保留原始字符串
        }

        // 处理重复键
        if (result[key] !== undefined) {
          if (Array.isArray(result[key])) {
            result[key].push(value);
          } else {
            result[key] = [result[key], value];
          }
        } else {
          result[key] = value;
        }
      }

      return result;
    }
  }
}

if (require.main === module) {

  const args = process.argv.slice(2);
  const command = args[0];

  switch (command) {
    case 'addKeyValueToJsonPath':
      if (args.length < 5) {
        console.log('请提供JSON文件路径、键路径、新键名和新值');
        console.log('用法: node i18nHelper.js addKeyValueToJsonPath <jsonFilePath> <keyPath> <newKey> <newValue>');
        console.log('示例: node i18nHelper.js addKeyValueToJsonPath ./src/locale/zh.json page.billList newKey "新值"');
      } else {
        const jsonFilePath = args[1];
        const keyPath = args[2];
        const newKey = args[3];
        const newValue = args[4];

        // 尝试解析newValue为JSON值（如果是数字、布尔值或对象）
        let parsedValue;
        try {
          parsedValue = JSON.parse(newValue);
        } catch (e) {
          // 如果解析失败，则视为字符串
          parsedValue = newValue;
        }

        const result = addKeyValueToJsonPath(jsonFilePath, keyPath, newKey, parsedValue);
        if (result) {
          console.log('添加键值对成功');
        } else {
          console.log('添加键值对失败');
        }
      }
      break;
    case 'addMultipleKeyValuesToJsonPath':
      if (args.length < 4 || (args.length - 3) % 2 !== 0) {
        console.log('请提供JSON文件路径、键路径和一系列的键值对');
        console.log('用法: node i18nHelper.js addMultipleKeyValuesToJsonPath <jsonFilePath> <keyPath> <key1> <value1> [<key2> <value2> ...]');
        console.log('示例: node i18nHelper.js addMultipleKeyValuesToJsonPath ./src/locale/zh.json page.billList key1 "值1" key2 "值2"');
      } else {
        const jsonFilePath = args[1];
        const keyPath = args[2];
        const keyValuePairs = [];

        // 解析所有键值对
        for (let i = 3; i < args.length; i += 2) {
          const key = args[i];
          const value = args[i + 1];

          // 尝试解析value为JSON值（如果是数字、布尔值或对象）
          let parsedValue;
          try {
            parsedValue = JSON.parse(value);
          } catch (e) {
            // 如果解析失败，则视为字符串
            parsedValue = value;
          }

          keyValuePairs.push({ key, value: parsedValue });
        }

        const result = addMultipleKeyValuesToJsonPath(jsonFilePath, keyPath, keyValuePairs);
        if (result) {
          console.log(`成功添加 ${keyValuePairs.length} 个键值对`);
        } else {
          console.log('添加键值对失败');
        }
      }
      break;
    case 'parseJSONWithDuplicates':
      if (args.length < 2) {
        console.log('请提供JSON字符串');
        console.log('用法: node i18nHelper.js parseJSONWithDuplicates <jsonString>');
        console.log('示例: node i18nHelper.js parseJSONWithDuplicates "{\"key\": \"value\", \"key\": \"value2\"}"');
      } else {
        const jsonString = args[1];
        const result = parseJSONWithDuplicates(jsonString);
        console.log('解析结果:', result);
      }
      break;
    default:
      console.log(`
          支持的命令:
            addKeyValueToJsonPath [JSON文件路径] [键路径] [新键名] [新值] - 向JSON文件的指定路径添加新的键值对
            addMultipleKeyValuesToJsonPath [JSON文件路径] [键路径] [键1] [值1] [键2] [值2] ... - 向JSON文件的指定路径一次性添加多个键值对
            parseJSONWithDuplicates [JSON字符串] - 解析JSON字符串，支持重复键
      `);
  }
}

module.exports = {
  addKeyValueToJsonPath,
  addMultipleKeyValuesToJsonPath,
  parseJSONWithDuplicates
}
